`:top
La `!programmation concurrente`! est un `F33f`_`[paradigme de programmation`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Paradigme_(programmation)]`_`f tenant compte, dans un programme, de l'existence de plusieurs piles sémantiques qui peuvent être appelées `F33f`_`[threads`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Processus_léger]`_`f, `F33f`_`[processus`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Processus_informatique]`_`f ou `F33f`_`[tâches`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Tâche_(informatique)]`_`f. Elles sont matérialisées en machine par une `F33f`_`[pile d'exécution`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Pile_d'exécution]`_`f et un ensemble de données privées.
La concurrence est indispensable lorsque l'on souhaite écrire des programmes interagissant avec le monde réel (qui est concurrent) ou tirant parti de multiples unités centrales (couplées, comme dans un système multiprocesseurs, ou distribuées, éventuellement en grille ou en grappe).
>>Contents
• `F0af`_`[Classification`#classification]`_`f
• `F0af`_`[Problèmes`#probl-mes]`_`f
• `F0af`_`[Solutions`#solutions]`_`f
• `F0af`_`[Voir aussi`#voir-aussi]`_`f
• `F0af`_`[Articles connexes`#articles-connexes]`_`f
• `F0af`_`[Liens externes`#liens-externes]`_`f
-─
>>Classification
On distingue trois types de concurrence :
• disjointe : les entités concurrentes ne communiquent pas et n'interagissent pas entre elles ;
• compétitive : un ensemble d'entités concurrentes en compétition pour l'accès à certaines ressources partagées (par exemple le temps CPU, un port d'entrées/sorties, une zone mémoire) ;
• coopérative : un ensemble d'entités concurrentes qui coopèrent pour atteindre un objectif commun. Des échanges ont lieu entre les processus. La coopération est un élément primordial de la programmation concurrente.
La programmation concurrente est plus complexe que la `F33f`_`[programmation impérative`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Programmation_impérative]`_`f, `F33f`_`[fonctionnelle`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Programmation_fonctionnelle]`_`f ou encore `F33f`_`[déclarative`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Programmation_déclarative]`_`f. En fait, à chacun de ces modèles de programmation, on peut associer une version concurrente, par extension de la sémantique du langage de programmation associé. Par exemple, `F33f`_`[Prolog`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Prolog]`_`f a été étendu en Concurrent Prolog, `F33f`_`[Haskell`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Haskell]`_`f avec Concurrent Haskell, `F33f`_`[Java`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Java_(langage)]`_`f et `F33f`_`[Ada`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Ada_(langage)]`_`f sont des langages à objets avec des primitives pour la concurrence, etc.
Les techniques spécifiques pour le traitement de la concurrence peuvent être classées en allant de la moins expressive (mais la plus facile à utiliser) à la plus expressive (et la plus complexe). On peut utiliser les niveaux suivants :
1. Concurrence déclarative (langage fonctionnel étendu avec des threads) ;
2. Concurrence en programmation logique ;
3. Concurrence déclarative avec des ports et envoi de messages ;
4. Concurrence impérative avec ports et envoi de messages ;
5. Concurrence impérative avec mémoire partagée.
>>Problèmes
Le phénomène central introduit par la concurrence est le suivant : dans un programme non concurrent, ou séquentiel, l'ordre d'exécution des instructions élémentaires du programme est un `F33f`_`[ordre total`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Relation_d'ordre]`_`f qui reste le même d'une exécution à l'autre pour les mêmes paramètres en entrée. Dans un programme concurrent, l'exécution forme un ordre partiel. Comme la politique d'`F33f`_`[ordonnancement`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Ordonnancement_dans_les_systèmes_d'exploitation]`_`f est généralement inconnue (elle est déterminée par le `F33f`_`[noyau`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Noyau_(informatique)]`_`f du `F33f`_`[système d'exploitation`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Système_d'exploitation]`_`f par exemple) ou incontrôlée, on parle de l'indéterminisme de l'ordre d'exécution.
Les problèmes induits par la concurrence se manifestent dans les cas de la concurrence compétitive et coopérative. À cause de l'indéterminisme de l'exécution, l'accès à des données partagées par les entités concurrentes peut conduire à des incohérences au niveau des relations liant ces données. Pour cela, on a historiquement utilisé différentes primitives de synchronisation comme les `F33f`_`[mutex`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Exclusion_mutuelle]`_`f, les `F33f`_`[moniteurs`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Moniteur_(informatique)]`_`f ou encore les `F33f`_`[sémaphores`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Sémaphore_(informatique)]`_`f. Ces différentes primitives sont toutes une forme plus ou moins évoluée de verrouillage qui sert à mettre en place la synchronisation des entités concurrentes (sur une ressource ou plus généralement une section critique). Mais leur utilisation ne s'effectue pas sans difficultés, on distingue notamment deux problèmes majeurs :
• `F33f`_`[interblocages`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Interblocage]`_`f (ou `*deadlocks`*) entre entités concurrentes (processus ou `*threads`*) qui attendent, par exemple, que l'autre relâche un verrou acquis pour pouvoir progresser ;
• `F33f`_`[famines`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Famine_(informatique)]`_`f (ou `*starvations`*) d'une entité (processus ou `*thread`*) essayant d'acquérir une ressource, mais jamais ordonnancé au moment où elle est disponible.
Des abstractions de plus haut niveau ont été développées afin de disposer de l'expressivité de la concurrence sans les inconvénients associés à l'usage des primitives de synchronisation de bas niveau.
>>Solutions
Pour chaque type de programmation concurrente, on dispose d'abstractions de haut niveau facilitant l'écriture de programmes concurrents.
Dans le cas de processus en compétition pour des ressources partagées, la notion de `F33f`_`[transaction`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Transaction_informatique]`_`f a été développée dès les années 1970. Les systèmes transactionnels, utilisés principalement pour des `F33f`_`[bases de données`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Base_de_données_relationnelle]`_`f partagées, s'appuient sur la théorie de la sérialisabilité pour garantir un accès concurrent à des ressources partagées (concurrence de type 4 et 5). La `F33f`_`[mémoire transactionnelle logicielle`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Mémoire_transactionnelle_logicielle]`_`f (STM) est une tentative pour appliquer ce modèle des transactions d'une façon plus générale à toute opération sur la mémoire, elle présente plusieurs avantages sur l'approche classique par verrous et connaît depuis peu un grand regain d'intérêt.
Dans le cas de processus en coopération en vue d'un but commun, au moins deux techniques ont fait leurs preuves : la communication inter-processus utilisant exclusivement l'envoi de messages, et la synchronisation `*dataflow`*, c’est-à-dire l'ordonnancement dynamique des `*threads`* en fonction de la disponibilité des données (au moyen de variables spéciales de type `F33f`_`[future`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Futures_(informatique)]`_`f ou variable logique). Les langages de programmation `F33f`_`[Erlang`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Erlang_(langage)]`_`f ou `F33f`_`[Oz`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Langage_Oz]`_`f permettent d'écrire des applications concurrentes et distribuées, avec un soin particulier apporté aux questions de `F33f`_`[gestion d'exception`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Système_de_gestion_d'exceptions]`_`f. Erlang et Oz exploitent le principe de l'envoi de messages, et Oz offre de plus la synchronisation `*dataflow`*.
>>Voir aussi
>>>Articles connexes
• `F33f`_`[Calcul distribué`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Calcul_distribué]`_`f : la concurrence est souvent liée à la distribution. Un programme dont l'exécution est distribuée sur plusieurs hôtes est intrinsèquement concurrent. Pourtant, ce n'est pas toujours le cas ; l'utilisation de protocoles de communication entre parties distribuées d'un programme, comme les `F33f`_`[RPC`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Remote_procedure_call]`_`f (appels de procédure à distance) ou `F33f`_`[RMI`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=RMI_(java)]`_`f (invocation de méthode à distance), peut rendre non-concurrent un programme distribué.
• `F33f`_`[Calcul parallèle`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Calcul_parallèle]`_`f
• `F33f`_`[Therac-25`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Therac-25]`_`f, un cas concret d'accidents liés à une mauvaise mise en œuvre
• `F33f`_`[distcc`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Distcc]`_`f, distribution des tâches de compilation
• langage `F33f`_`[Portal`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Portal_(langage)]`_`f
• langage `F33f`_`[Occam`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Occam_(langage)]`_`f
• langage `F33f`_`[Ada 95`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Ada_(langage)]`_`f
• langage `F33f`_`[Rust`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=Rust_(langage)]`_`f, conçu pour être « un langage sécurisé, concurrent, pratique »
• programmation `F33f`_`[LabVIEW`:/page/wikibook/entry.mu`zim=wikipedia_fr_all_nopic_2025-10.zim|entry_path=LabVIEW]`_`f
>>Liens externes
• Notice dans un dictionnaire ou une encyclopédie généraliste : `*Britannica`*
• Portail de la programmation informatique
`c`F0af`_`[↑ Back to top`#top]`_`f`a